package com.browsesoft.baseadapter;

import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import com.aote.entity.EntityType;
import com.aote.entity.EntityTypeFactory;
import com.aote.entity.EntityTypeNotFoundException;
import com.aote.serialnumber.IncreaseSerialFactory;
import com.aote.serialnumber.IncreaseSerialNumber;
import com.aote.util.StringHelper;
import com.browsesoft.Entity;
import com.browsesoft.EntityManager;
import com.browsesoft.SequenceFind;
import com.browsesoft.dbtools.DBTools;
import com.browsesoft.dbtools.DataConvert;

/**
 * <p>
 * Title:
 * </p>
 * <p>
 * Description:
 * </p>
 * <p>
 * Copyright: Copyright (c) 2002
 * </p>
 * <p>
 * Company:
 * </p>
 * 
 * @author not attributable
 * @version 1.0
 */
public abstract class BasicEntity implements Entity, DataConvert, Cloneable {
	/**
	 * 表名
	 */
	protected String tableName;

	/**
	 * 类型
	 */
	public String entityType;

	/**
	 * 属性
	 */
	public Hashtable attributes = new Hashtable();

	/**
	 * 保存编号
	 */
	protected Map numbers = new HashMap();

	/**
	 * 构造
	 */
	public BasicEntity() {
		try {
			// 设置对象号
			String id = Integer.toString(SequenceFind.getID());
			this.attributes.put("id", id);
			// 设置多版本时，不同版本，同一个对象的唯一标识
			id = SequenceFind.getID() + "";
			this.attributes.put("selfid", id);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}

	/**
	 * 构造
	 * 
	 * @param attr
	 *            属性
	 */
	public BasicEntity(Hashtable attr) {
		this.attributes.putAll(attr);
		this.entityType = (String) attr.get("entitytype");
		this.tableName = (String) attr.get("tablename");
		this.numbers = StringHelper.parseAttributes((String) attr
				.get("abonumber"));
	}

	/**
	 * 插入一条内容
	 * 
	 * @throws java.lang.Exception
	 */
	public void insert() throws java.lang.Exception {
		// 往数据库中添加
		this.insertToDB();
		EntityType type = null;
		try {
			type = EntityTypeFactory.getInstance().getEntityType(
					this.entityType);
		} catch (EntityTypeNotFoundException e) {
			// 实体类型不存在，肯定不是延迟加载，不管
		}
		// 如果不是延迟加载对象
		if (type == null || !type.isLazy()) {
			// 向管理器中加入内容
			EntityManager.getInstance().add(this);
		}
	}

	/**
	 * 对象只写库，不向管理器中添加内容
	 * 
	 * @param createTable
	 *            是否建立表结构
	 */
	public void insertToDB(boolean createTable) {
		try {

			// 写库
			EntityManager.getInstance().insertToDB(this, createTable);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 对象只写库，不向管理器中添加内容
	 * 
	 */
	public void insertToDB() {
		this.insertToDB(true);
	}

	/**
	 * 更新内容
	 * 
	 * @throws java.lang.Exception
	 */
	public void update() throws java.lang.Exception {
		// 更新数据库
		DBTools.update(tableName, this.getID(), this.getAttributes());
	}

	/**
	 * 删除内容
	 * 
	 * @throws java.lang.Exception
	 */
	public void delete() throws java.lang.Exception {
		// 从管理器中删除
		EntityManager.getInstance().remove(this);
		// 从数据库中删除
		DBTools.delete(tableName, getID());
	}

	/**
	 * 得到ID
	 * 
	 * @return id
	 */
	public String getID() {
		return (String) this.getAttributes().get("id");
	}

	/**
	 * 创建关系
	 */
	public void createRelation() {
	}

	/**
	 * 得到属性
	 * 
	 * @return 属性
	 */
	public Hashtable getAttributes() {
		return this.attributes;
	}

	/**
	 * 设置表名
	 * 
	 * @param name
	 *            表名
	 */
	public void setTableName(String name) {
		this.tableName = name;
	}

	/**
	 * 得到表名
	 * 
	 * @return 表名
	 */
	public String getTableName() {
		// 如果表名为空，从属性中得到表名
		if (this.tableName == null || this.tableName.equals("")) {
			this.tableName = (String) this.getAttributes().get("tablename");
		}
		return this.tableName;
	}

	/**
	 * 更新属性
	 * 
	 * @param hashtable
	 *            属性集
	 * @throws Exception
	 */
	public void updateAttributes(Hashtable hashtable) throws Exception {
	}

	/**
	 * 设置实体类型
	 * 
	 * @param typeName
	 *            类型
	 */
	public void setEntityType(String typeName) {
		this.entityType = typeName;
	}

	/**
	 * 得到实体类型
	 * 
	 * @return 实体类型
	 */
	public String getEntityType() {
		return this.entityType;
	}

	/**
	 * @return id
	 */
	public String toString() {
		return this.getID();
	}

	/**
	 * 转换数据
	 */
	public void convert(int count) {
		try {
			if (count == 0) {
				this.insertToDB(true);
			} else {
				// 不建立数据库结构，往数据库中添加
				this.insertToDB(false);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public void sychronUpdate(Hashtable attributes) {
		this.attributes = attributes;
	}

	public void sychronDelete() {
		EntityManager.getInstance().remove(this);
	}

	/**
	 * 编号失效
	 */
	public void expirationNumber(String name) {
		String realName = StringHelper.replaceStr(this.attributes, name, "*");
		String expnumber = (String) numbers.get(realName);
		IncreaseSerialNumber num = IncreaseSerialFactory.getInstance()
				.getSerialNumber(realName);
		num.addExpirationNum(expnumber);
	}

	/**
	 * 保存或者更新
	 */
	public void saveOrUpdate() {
		try {
			// 如果可以加载到实体，更新，否则，插入
			String cond = "id='" + this.getID() + "'";
			System.out.println("cond-->" + cond);
			Collection coll = EntityManager.getInstance().getEntities(
					this.entityType, cond);
			if (!coll.isEmpty()) {
				System.out.println("更新");
				this.update();
			} else {
				System.out.println("新增");
				this.insert();
			}
		} catch (Exception e) {
			try {
				this.insert();
			} catch (Exception ex) {
				throw new RuntimeException(ex);
			}
		}
	}
}